//用嵌套类:

// #include <iostream>
// #include <cassert>
// using namespace std;

// class Matrix
// {
// public:
//     Matrix(int r = 0, int c = 0);
//     class Array //定义为公开，所有地方都可以访问
//     {
//         friend class Matrix; //Matrix可以访问  Array的所有成员变量

//         int &operator[](int j) const; //列标
//     private:
//         int size;
//         int *a;
//     };
//     Array &operator[](int i) const //行标
//     {
//         return arr[i];
//     }

// private:
//     int row;    //初始化成10
//     int col;    //10
//     int size;   //10
//     Array *arr; //内部类的对象数组
// };

// Matrix::Matrix(int r, int c)
// {
//     assert(r > 0 && c > 0);
//     row = r; //10
//     col = c; //10
//     int i, j;
//     size = r;           //10
//     arr = new Array[r]; //对象数组  r个对象
//     for (i = 0; i < c; i++)
//     {
//         arr[i].a = new int[c]; //r个对象，每一个对象的数据成员a都有 c个int大小的内存
//         arr[i].size = c;
//     }
//     //赋值
//     for (i = 0; i < r; i++)
//     {
//         for (j = 0; j < c; j++)
//         {
//             arr[i].a[j] = i * col + j;
//         }
//     }
// }

// int &Matrix::Array::operator[](int j) const
// {
//     return a[j];
// }

// int main()
// {
//     Matrix m(10, 10);
//     int tmp = m[2][6]; //[][]确实是两次运算，而不是一个运算符。m[i][j] 在C＋＋里相当于：m.operator[](i).operator[](j)
//     cout << tmp << endl;
//     return 0;
// }

// #include <cstdio>
// #define MAXN 100
// struct A
// {
//     struct B
//     {
//         int val[MAXN];
//         int &operator[](const int p)
//         {
//             return val[p];
//         }
//     } val[MAXN];

//     B &operator[](const int p)
//     {
//         return val[p];
//     }

// };
// int main()
// {
//     static A x;
//     x[1][2] = 9;
//     printf("%d\n", x[1][2]);
// }

//方法二
#include <iostream>
#include <cstring>
using namespace std;
class Array2
{
private:
    int row;    //数组行数
    int column; //数组列数
    int *ptr;   //指向二维数组的指针
public:
    Array2()
    {
        ptr = NULL;
    }
    Array2(int paraRow, int paraColumn) : row(paraRow), column(paraColumn)
    {
        ptr = new int[row * column];
    }
    Array2(Array2 &a) : row(a.row), column(a.column)
    {
        ptr = new int[row * column];
        memcpy(ptr, a.ptr, sizeof(int) * row * column);
    }
    Array2 &operator=(const Array2 &a)
    {
        if (ptr)
            delete[] ptr;
        row = a.row;
        column = a.column;
        ptr = new int[row * column];
        memcpy(ptr, a.ptr, sizeof(int) * row * column);
        return *this;
    }
    ~Array2()
    {
        if (ptr)
            delete[] ptr;
    }
    int *operator[](int i)
    {
        return ptr + i * column;
    }
    int &operator()(int i, int j)
    {
        return ptr[i * column + j];
    }
};
int main()
{
    Array2 a(3, 4);
    int i, j;
    for (i = 0; i < 3; ++i)
        for (j = 0; j < 4; j++)
            a[i][j] = i * 4 + j;
    for (i = 0; i < 3; ++i)
    {
        for (j = 0; j < 4; j++)
        {
            cout << a(i, j) << ",";
        }
        cout << endl;
    }
    cout << "next" << endl;
    Array2 b;
    b = a;
    for (i = 0; i < 3; ++i)
    {
        for (j = 0; j < 4; j++)
        {
            cout << b[i][j] << ",";
        }
        cout << endl;
    }
    return 0;
}

// // ----------------------------------------------方法三

// //一维WORD数组
// #include <iostream>
// #include <cstring>
// using namespace std;

// typedef int WORD;

// class CWordArr
// {
// private:
//     WORD *m_pdat;
//     long m_size;

// public:
//     CWordArr(long size)
//     {
//         m_pdat = new WORD[size];
//         m_size = size;
//              cout << "调用类一的构造函数" << endl;//测试代码
//                  cout << size << endl;//测试代码
//     };
//     ~CWordArr()
//     {
//         delete[] m_pdat;
//     };
//     WORD &operator[](long idx)//6-调用列指针
//     {
//         return m_pdat[idx];
//     }
// };

// //二维WORD数组
// class C2DimWordArr
// {
// private:
//     CWordArr **m_p;       //主指针
//     long m_row, m_column; //行数，列数。

// public:
//     C2DimWordArr(long row, long column)
//     {
//         m_p = new CWordArr *[row];    //2-为二级指针分配行空间，共4行（4个一级指针的空间）
//         for (long i = 0; i < row; i++)
//         {
//             m_p[i] = new CWordArr(column);//3-在这里调用了类一 CWordArr的构造函数  为每行分配列空间，每行共3列
//         }
//         执行完成之后就分配好了4行3列的内存空间。

//     m_row = row;
//         m_column = column;
//         cout << "调用类二的构造函数" << endl;
//     }
//     ~C2DimWordArr()
//     {
//         for (long i = 0; i < m_row; i++)
//         {
//             delete m_p[i];
//             m_p[i] = NULL;
//         }
//         delete[] m_p;
//     }
//     CWordArr &operator[](long idx)//5-先调用类二函数
//     {
//         return *m_p[idx];//返回行指针，（返回一个对象，去调用类一的运算符重载函数）
//     }
// };

// //--------------------------------------------------------------------------------------
// //主调代码如下，验证类的正确性：
// //--------------------------------------------------------------------------------------
// int main()
// {

//     C2DimWordArr c2dwa(4, 3);
// 1-创建对象c2dwa时 调用类  C2DimWordArr的构造函数
//     long i, j;
//     for (i = 0; i < 4; i++)
//     {
//         for (j = 0; j < 3; j++)
//         {
//             c2dwa[i][j] = i * 10 + j;   //4——根据for循环调用运算符重载函数。c2dwa[i][j]相当于c2dwaoperator[](i).operator[](j)
//         }
//     }

//     for (i = 0; i < 4; i++)
//     {
//         for (j = 0; j < 3; j++)
//         {
//             cout << c2dwa[i][j] << endl;
//         }
//     }
//     return 0;
// }
